Pseudo-random sequence generator

ABSTRACT

A seed random sequence is extended in successive nodes of a tree structure of a random sequence generator. At each node, an input sequence is expanded to an output sequence substantially greater than the length of the input sequence. Plural processors operate in parallel in generating the final output sequence, and subsequences may be directly accessed as a starting location of the output sequence. The random sequence generator is accessed by an index in an encryption system. In a sequential generator, less than all of the bits from the generator unit are reapplied to the generator unit in an iterative process.

BACKGROUND OF THE INVENTION

A random number generator (RNG) is an efficient device that transforms short random seeds into long pseudo-random strings. A classical RNG is the linear congruential generator (LCG) that is based on the recursion x_(i+1) =ax_(i) +b(mod N). It is well known that the LCG passes certain statistical tests, e.g., for a clever choice of the parameters a,b,N it generates well mixed numbers (see Knuth 1980). There are more elaborate statistical tests which the LCG fails. Stern (1987) shows that the sequence generated by the LCG can be inferred even if the parameters a,b,N and the seed x₀ are all unknown.

The concept of a perfect random number generator (PRNG) has been introduced by Blum, Micali (1982) and Yao (1982). A RNG is perfect if it passes all polynomial time statistical tests, i.e., the distribution of output sequences cannot be distinguished from the uniform distribution of sequences of the same length. So far, the proofs of perfectness for the known PRNG's are all based on unproven complexity assumptions. This is because superpolynomial complexity lower bounds cannot be proven.

Perfect random number generators have been established, for example, based on the discrete logarithm by Blum, Micali (1982), based on quadratic residuosity by Blum, Blum, Shub (1982), based on one way functions by Yao (1982), and based on Rivest/Shamir/Adleman (RSA) encryption and factoring by Alexi, Chor, Goldreich and Schnorr (1984). All these PRNG's are less efficient than the LCG. The RSA/RABIN-generators are the most efficient of these generators. They successively generate log N pseudo-random bits by one modular multiplication with a modulus that is N bit long.

Disclosure of the Invention

In accordance with the present invention, a random sequence generator generates a random sequence from a seed random sequence which is of substantially shorter length. Most likely, the seed would be truly random and the generated sequence would be pseudo-random, but the term "random" is used to include both random and pseudo-random sequences. The generator performs a tree operation by extending, at each node of a tree structure, a node input random sequence. A plurality of node output sequences of the tree structure together comprise a final random output sequence. The final random output sequence is preferably generated as successive leaves of the tree structure. The tree structure allows for direct access to any leaf as a starting leaf of a sequence. The parallel structure of the tree allows for generation of the sequence with parallel processors which, but for initial seeds, may operate independently of each other.

In a preferred embodiment, each node input sequence is extended by the RSA operation

    y=a.sub.e x.sup.e +a.sub.e-1 x.sup.e-1 + . . . +a.sub.1 x+a.sub.0 (mod N)

where e, a_(e), a_(e-1), . . . , a₀ and N are integers, the node input sequence represents x and the node output sequence represents y. In a preferred system, the RSA function is reduced by setting all a's equal to zero except one, a_(d), which is set to equal one. The greatest common divisor of d and Euler's Totient function φ(N) is equal to one. Specifically, N is the product of two large random primes p and q, and d is an integer that is relatively prime to (p-1) (q-1), preferably 3.

In either a sequential or a tree operation, the final sequence is generated in iterative steps. At each step, a new string of bits is obtained by applying a function to significantly less than all of the bits of a previous string. At least part of the bits of a previous string to which the function is not applied are utilized toward the output, either directly or with application of the function in a tree structure.

One application of the random sequence generator is in an encryption system. An encryption unit performs a transform between an encrypted message and a nonencrypted message using the random sequence generated by the random sequence generator. An index may be applied to the generator to indicate the leaf of the tree at which the sequence applied to the encryption unit begins.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a schematic illustration of a random sequence generator having an output sequence y greater in bit length than an input sequence x.

FIG. 2 is an illustration of a random sequence generator having a tree structure in accordance with the present invention, each node comprising a generator as illustrated in FIG. 1.

FIG. 3 illustrates a multiprocessor system for performing the tree structure of FIG. 2.

FIG. 4 illustrates an encryption system utilizing the generator of FIG. 2.

FIG. 5 illustrates a sequential polynominal generator.

FIG. 6 is another illustration of a sequential polynomial generator.

FIG. 7 is another illustration of a parallel polynomial generator.

FIG. 8 is an illustration of yet another parallel polynomial generator.

DESCRIPTION OF PREFERRED EMBODIMENTS

An electronic random number generator, or random sequence generator, takes an input sequence of some number of bits which represents an input x and extends that sequence to a sequence of bits which represents a number y, the number of bits representing y being greater than the number of bits representing x. There are many functions which can easily extend the number m of bits by a factor of about 2. Difficulties in designing random generators exist, however, when substantially longer output sequences are required from a given length seed sequence. At some length, degradation of the output, such that it can no longer be considered random, is encountered.

In accordance with the present invention, a random sequence need only be expanded by a factor of about 2 in the generator 12. With such a short output sequence, the output can be considered near perfectly random. In accordance with the present invention, that perfectly random output is further extended in successive operations of the same generator 12 in a data processor tree structure illustrated in FIG. 2. The initial input sequence is first expanded by a factor of about 2 in a generator 12A. Portions of the output sequence from generator 12A are applied to respective inputs of generators 12B and 12C. Each of those generators then further expands the random sequence. For example, portions of the output from generator 12B are applied to the inputs of respective generators 12D and 12E.

It will be recognized that the output sequence of the generator need not have exactly twice the number of bits of the input sequence. Some bits from a larger output sequence may be ignored, or there may be overlap in the bits applied to the respective generators if the number of bits in the output y is less than twice the number of bits in the input x. Also, no particular portion of the output sequence need be passed on to each successive generator. Further, although a binary tree is most convenient, tertiary and wider trees may be used.

It is recognized that for a short output sequence y₀, y₁, y₂ . . . , the binary tree adds unnecessary operations in the overall generation. With a tree of K levels of generators, K operations would be required to generate the bit sequence y₀. However, any sequence y_(i) of the y.sub.(2 K-1.sub.) sequences can be accessed with the same number of operations, and for a very long sequence the tree becomes efficient because each simple generator operation in the tree supports generation of plural sequences y_(i) provided at the leaves of the tree. Thus, to provide a final sequence formed of 2^(K-1) leaves, each of a predetermined bit length, the tree need only perform (2^(K) -1) operations through K generator levels. This process can be made very rapid by the use of parallel processors, as illustrated by FIGS. 2 and 3.

FIG. 3 illustrates four random generators G₀, G₁, G₂ and G₃ which may operate independently of each other. Each generator receives a sequential node input sequence from a respective random access memory, RAM₀, RAM₁, RAM₂, RAM₃, and outputs a longer sequence which is itself stored in the respective RAM for application to the generator at successive nodes of the tree. At the first node of the tree, only generator G₀ performs an operation. A portion of its output is retained in RAM₀, and a portion is transferred by the CPU to RAM₂. In the next level of the tree, generators G₀ and G₂ perform their respective operations to provide extended node output sequences. A portion of the output from G₀ is again stored in RAM₀, and another portion is stored in RAM₁. Similarly, a portion of the output from generator G₂ is stored in RAM₂, and a portion is stored in RAM₃. Output sequences from the nodes need only be stored until input to both nodes of a lower level. From FIG. 2, it can be seen that, in all levels of the tree below the third, the processors and associated RAMs may operate independently. It can be seen that four processors reduce the processing time for a full length sequence almost to one-fourth the processing time of a single generator. Additional processors will of course further reduce the processing time of a large binary tree.

In some applications, such as in cryptography, it may be desirable to have a very long random sequence available but to be able to select a different starting point within the sequence for each encoding operation. The binary tree structure of FIG. 2 allows any subsequence y_(i) to be accessed in K operations by simply defining the path through the binary tree to that leaf. Successive leaves may then be generated with relatively few additional operations because of the shared nodes through the tree. In other applications, a more rapid output of the initial subsequences may be desired. In that case, the initial subsequences may be output from nodes other than the leaves at the lower level of FIG. 2.

FIG. 5 illustrates an encryption system utilizing the random sequence generator of FIG. 2. In the system, a message M is encrypted in a sending unit 14, transferred over publicly accessible communications link 16 as an encrypted message C and decrypted to readable form at a receiving unit 18. Each of the sending and receiving units comprises an encryption unit, the encrypter 20 of the sending unit 14 and the decrypter 22 of the receiving unit. The two units also have identical random sequence generators 24 and 26 which are of the form illustrated in FIG. 2.

Conventional encryption systems utilize a random sequence, which is shared by both the sending and receiving units but is unknown to the public, to first encrypt the message and then decrypt the message. The random sequences must be transferred from one unit to another in a secure fashion for later use. To maintain the security of the system, longer sequences are best used with each encryption, and different sequences are best used in successive encryptions. This ordinarily requires that either a very long random sequence be transferred, or that only a seed x be transferred and that a random sequence generator be used to extend the seed x.

A drawback of conventional random sequence generators is that they are sequential in nature, and thus the sequence must be generated from the beginning to access a subsequence within the overall sequence. An advantage of the sequence generator of FIG. 2 is that the leaves y_(i) are individually accessible by merely specifying the path to that sequence through the tree as by an index i. Thus, in the system of FIG. 4, an index i is applied to the sequence generator 24 at the sending unit to access a sequence which begins at y_(i). That index is also communicated to the receiving unit so that the same sequence beginning at y_(i) can be generated for decryption. Thus, by securely transferring a short seed x and providing each of the units with an identical sequence generator, any extended portion of the entire sequence y₀, y₁, . . . , y.sub.(2 K.sub.) can be accessed by an index i, and the first subsequence of the accessed sequence is obtained in K operations.

A preferred generator for use at each node of the tree of FIG. 2 is a simplified RSA generator in which the input sequence is extended by the modular operation y=ax^(d) (mod N), where N is the product of two large random primes p and q, and d is an integer that is relatively prime to (p-1) (q-1). Preferably, a equal 1, d=3, and the bit length of x is short relative to the bit length of N. For example, the bit length of x may be 2/3 that of N.

The full RSA function, presented by Rivest et al. in U.S. Pat. No. 4,405,829, is as follows:

    y=a.sub.e x.sup.e +a.sub.e-1 x.sup.e-1 + . . . +a.sub.1 x+a.sub.0 (mod N)

where e, a_(e), a_(e-1), . . . , a₀ and N are integers. For security, there should be at least one a_(d) of a_(e), a_(e-1), . . . , a₃ which is not equal to zero, and the greatest common divisor of d and Euler's Totient function φ(N) is equal to one. One such d is 3.

The advantage of the function y=x³ (mod N) where x is short relative to N is that the output sequence is near twice the length of the input sequence with only two multiplications by x and a division by N to determine the remainder. The same number of operations would be required for d=4, but the output would not be so perfectly random unless some bits of (information about) y=x^(d) (mod N) are discarded. Even so, the output would be longer than the input sequence.

In prior uses of the RSA function in random generators, an extended output from a seed is generated by iterative operations of the function while outputing a limited number of bits from each operation. Therefore, with each operation of the RSA function, a number of bits less than the number of input bits would be output in the output sequence. A longer output sequence is obtained only by continued iterations of the RSA operation. Subsequences y_(i) are not accessible directly, and multiple processors cannot perform independently in parallel to more rapidly generate the sequence. In the present system, the full output of a single RSA operation, or at least a number of bits greater than the number of bits in the input, is applied to the next level of the binary tree. Subsequences are directly accessible, and parallel processing can be used to great advantage.

As noted above, from each operation of the generator G, a number of bits greater than the number of bits in the input to the generator are utilized toward the final output. Because of the security of the particular RSA function utilized in the generator, even sequential generators having this feature may be designed as illustrated in FIG. 5. In this figure, each of the generators G may perform the RSA function y=x^(d) (mod N). The bit length of each output y of each generator is significantly longer than the bit length of each input. Thus, less than all of the bits output from each generator are applied to the next generator. A significant number of bits, particularly those not applied to the next generator, are available for output.

This sequential generator allows for the very rapid generation of a relatively long sequence. It is much more rapid than the usual generators based on the RSA function because such generators reapply the full output sequence from each generator to the next generator in the iterative process, and only a few bits are output from each step of the process. Because of the high security of the particular RSA function chosen in the present application, fewer bits need be applied to each generator, for more rapid processing at individual generators, and a larger number of bits may be output from each individual generator, for more rapid output of the full random sequence. The sequential generator of FIG. 5 does suffer the disadvantage of the typical RSA generator in that individual subsequences of the output are not directly accessible.

A more theoretical discussion of the function used in the generator G and of the parallel tree structure and sequential generator follows.

We extend and accelerate the RSA-generator in various ways. We give evidence for more powerful complexity assumptions that yields more efficient generators. Let N=pq be product of two large random primes p and q and let d be a natural number that is relatively prime to φ(N)=(p-1)(q-1). We conjecture that the following distributions are indistinguishable by efficient statistical tests (see Hypothesis 2.1):

the distribution of x^(d) (mod N) for random xε[1,N^(2/d) ].

the uniform distribution on [1,N].

This hypothesis is closely related to the security of the RSA-scheme. Under this hypothesis the transformation

    [1,N.sup.2/d ] x→x.sup.d (mod N)ε[1,N]

stretches short random seeds xε[1,N^(2/d) ] into a pseudo-random numbers x^(d) (mod N) in the interval [1,N]. We build various random number generators on this transformation. The sequential polynomial generator (SPG) generates from random seed xε[1,N^(2/d) ] a sequence of numbers x=x₁,x₂, . . . , x₁, . . . ε[1,N^(2/d) ]. The n(1-2/d) least significant bits of the binary representation of x_(i) ^(d) (mod N) are the output of x_(i) and the 2n/d most significant bits form the successor x_(i+1) of x_(i), where n is the number of bits in N.

It follows from a general argument of Goldreich, Goldwasser, Micali (1986) and the above hypothesis that all these generators are perfect, i.e. the distribution of output strings is indistinguishable, by efficient statistical tests, from the uniform distribution of binary strings of the same length. The sequential generator is nearly as efficient as the LCG. Using a modulus N, that is n bit long, it outputs n(1-2/d) pseudo-random bits per iteration step. The costs of an iteration step x→x^(d) (mod N) with xε[1,N^(2/d) ] corresponds to the costs of a about one full multiplications modulo N. This is because the evaluation of x^(d) (mod N) over numbers x≦N^(2/d) consists almost entirely of multiplications with small numbers that do not require modular reduction.

We extend the SPG to a parallel polynomial generator (PPG). The PPG generates from random seed xε[1,N^(2/d) ] a tree. The nodes of this iteration tree are pseudo-random numbers in [1,N^(2/d) ] with outdegree at most d/2. To compute the successor nodes y(1), . . . , y(s) and the output string of node y we stretch y into a pseudo-random number y^(d) (mod N) that is n bit long. Then the successors y(1), . . . , y(s) of y are obtained by partitioning the most significant bits of y^(d) (mod N) into s≦d/2 bit strings of length 2n/d . The output of node y consists of the remaining least significant bits of y^(d) (mod N). Any collection of subtrees of the iteration tree can be independently processed in parallel once the corresponding roots are given. In this way m parallel processors can speed the generation of pseudo-random bits by a factor m. These parallel processors need not to communicate; they are given pseudo-independent input strings and their output strings are simply concatenated. The concatenated output of all nodes of the iteration tree is pseudo-random, i.e. the parallel generator is perfect. The PPG enables fast retrieval of substrings of the pseudo-random output. To access a node of the iteration tree we follow the path from the root to this node. After retrieving a bit the subsequent bits in the output can be generated at full speed. Iteration trees of depth at most 30 are sufficient for practical purposes; they generate pseudo-random strings of length 10²⁰ (for outdegree 4) such that individual bits can be retrieved within a few seconds.

The Complexity Assumption for the Polynomial Random Generator

Let P(x) be a polynomial of degree d≧2 with integer coefficients and let N be an integer that is n bits long, i.e. 2^(n-1) ≦N<2^(n). We denote l= 2n/d . Residue classes modulo N are identified with the corresponding integers in the interval [1,N].

The polynomial generator is based on the transformation

    [1,M] x→P(x) mod N                                  (1)

where x ranges over a sufficiently large subinterval [1,M] of [1,N]. We would like that the outputs of (1), for random xε[1,M] and given N, M and P, be indistinguishable from random yε[1,N]. The following conditions and restrictions are clearly necessary.

the modulus N must be difficult to factor since given the factorization of N we can easily invert (1).

M must be sufficiently large to make P(x)/N large for almost all xε[1,M]. This is because we can easily invert (1) provided that P(x)/N is small.

P(x) must not be a square polynomial. If P(x)=Q(x)² for some polynomial Q then the Jacobi-symbol ##EQU1## is 1 for all x whereas prob ##EQU2## for random yε[1,N]. Since the Jacobi-symbol can be evaluated efficiently we can distinguish P(x) mod N from random numbers yε[1,N].

P(x) must not be a linear transform of a square polynomial. If P(x)=aQ(x)² +b we can, from P(x) mod N, recover Q(x)² mod N and check that ##EQU3##

We choose N,M,P(x) as to correspond to these conditions. Let N be a random number that is uniformly distributed over the set ##EQU4## of integers that are products of two distinct primes which each is n/2 bits long. We choose arbitrary M that are proportional to 2^(l), M=θ(2^(l)); i.e. 1/c≦2^(l) /M≦c for some absolute constant c>0. Then M is proportional to N^(2/d) for all NεS_(n). The choice for the polynomials P(x) seems to be subject to only a few restrictions. We are going to study a particular class of permutation polynomials where the hypothesis below can be justified by known theory. These are the RSA-polynomials P(x)=x^(d) with d relatively prime to φ(N)=(p-1)(q-1).

Rivest, Shamir and Adleman (1978) have invented the RSA-cryptoscheme that is based on the multiplicative group

     * .sub.N ={x(mod N)|gcd(x,N)=1}

of residue classes modulo N that are relatively prime to N. The integer N is product of two odd primes, N=p.q. The order of the group * _(N) is φ(N)=(p-1)(q-1). The transformation

    x→x.sup.d (mod N)                                   (2)

with gcd(φ(N),d)=1 is a permutation on the residue classes modulo N, i.e. it permutes the integers in the interval [1,N]. The inverse transformation is given by x→x^(e) (mod N) where e=d⁻¹ modφ(N). The permutation (2) with gcd(φ(N),d)=1 and d≠1 is an RSA-enciphering function. The enciphering key d does not reveal the inverse key e provided that φ(N) is unknown. Knowledge of φ(N) is equivalent to knowing the factorization N=p.q. The security of the RSA-scheme relies on the assumption that RSA-enciphering x→x^(d) (mod N) is difficult to invert when d, N are given but φ(N) and e=d⁻¹ modφ(N) are unknown. All known methods for inverting RSA-enciphering require the factorization of N.

We are going to show that the following hypothesis is closely related to the security of the RSA-scheme. Our random number generators will rely on this hypothesis.

Hypothesis 2.1 Let d≧3 be an odd integer and l= 2n/d . For random NεS_(n) such that gcd(d,φ(N))=1 and for all M=θ(2^(l)) the following distributions on [1,N] are indistinguishable by polynomial time statistical tests:

the uniform distribution on [1,N],

x^(d) (mod N) for random xε[1,M].

We explain the hypothesis in more detail. The concept of a statistical test has been introduced by Yao (1982). A polynomial time statistical test is a sequence T=(T_(n))_(n)ε of probabilistic algorithms with a uniform polynomial time bound n^(o)(1). According to Yao it is sufficient to consider statistical tests with 0,1-output. Let

    p.sub.n.sup.T =prob[T.sub.n (y,N)=1]

be the probability that T_(n) outputs 1. The probability space is that of all integers NεS_(n) with gcd(d,φ(N))=1, all numbers yε[1,N] and all 0-1 sequences of internal coin tosses, with uniform distribution. Let ##EQU5## be the same probability with random numbers yε[1,N] replaced by y=x^(d) (mod N) for random xε[1,M]. The hypothesis means that for every polynomial time statistical test T and all M_(n) =θ(2^(l)) ##EQU6## We say that the statistical test T ε_(n) -rejects RSA-ciphertexts x^(d) (mod N) of random xε ##EQU7## for infinitely many n. If (3) holds for all polynomial time statistical tests T we call RSA-ciphertexts x^(d) (mod N) of random messages xε[1,M_(n) ] pseudo-random in [1,N]. In this case the distributions of x^(d) (mod N) for random xε[1,M_(n) ] and the uniform distribution on [1,N] are called indistinguishable.

In general two sequences of distributions (D_(n))_(n)ε and (D_(n))_(n)ε are called indistinguishable if for every pol. time statistical test (T_(n))_(n)ε , that is given random inputs with respect to D_(n) (D_(n), resp.) the probability ##EQU8## resp.) of output 1 satisfy lim ##EQU9## for all t≧0. In case of indistinguishable distributions D_(n),D_(n) and if D_(n) is the uniform distribution on set C_(n) then random elements with respect to D_(n) are called pseudo-random in C_(n). In case of pseudo-random pairs (x,y) we call x and y pseudo-independent. A random number generator is called perfect if it transforms random seeds into pseudo-random strings.

It can easily be seen that the Hypothesis 2.1 can only fail if RSA-enciphering leaks partial information on RSA-messages.

Fact 2.2 Suppose Hypothesis 2.1 fails. Then given d and N we can distinguish between RSA-ciphertexts x^(d) (mod N) of random messages xε[1,N] and of random messages xε[1,M_(n) ] for some M_(n) =θ(2^(l)).

Proof The transformation x→x^(d) (mod N) permutes the integers in the interval [1,N]. The RSA-enciphering x^(d) (mod N) of random messages xε[1,N] is uniformly distributed over [1,N]. If Hypothesis 2.1 fails the uniform distribution can be distinguished from RSA-ciphertexts x^(d) (mod N) for random xε[1,M_(n) ]; i.e. RSA-ciphertexts x^(d) (mod N) would leak information on whether the message x is contained in [1,M_(n) ]. QED

We do not claim that the RSA-scheme breaks down if the hypothesis fails. This is because messages in the interval [1,2^(l) ] are rather unlikely. Nevertheless the hypothesis is close to the security of the RSA-scheme. Using the following Theorem 2.3 we can relate the hypothesis to RSA-security (see Corollary 2.5).

Theorem 2.3 Alexi, Chor, Goldreich, Schnorr (1985)

Let d,N be integers such that gcd(d,φ(N))=1. Every probabilistic algorithm AL, which given the RSA-enciphering x^(d) (mod N) of a message x, has an ε_(N) -advantage in guessing the least significant bit of the message x can be transformed (uniformly in N) into a probabilistic algorithm AL for deciphering arbitrary RSA-ciphertexts. The deciphering algorithm AL, when given for input x^(d) (mod N), d and N, terminates after at most ##EQU10## elementary steps and outputs x with probability at least 1/2.

We count for elementary steps the _(N) operations (addition, multiplication, division), RSA-encryptions and calls for algorithm AL at unit cost. We say that algorithm AL has an ε_(N) -advantage in guessing the least significant bit of x if ##EQU11## The probability space is the set of all xε[1,N] and all 0-1 sequences of internal coin tosses, with uniform probability.

By Theorem 2.3 the security of the RSA-scheme with parameters N, d implies that the following two distributions cannot be distinguished given only N and d:

the uniform distribution on [1,N],

x^(d) (mod N) for random, even xε[1,N].

Everyone who is able to distinguish these distributions can decode arbitrary RSA-ciphertexts x^(d) (mod N) given only N and d. We will present in Corollary 2.4 a more formal version of this statement.

We say that a probabilistic algorithm AL ε_(N) -rejects the distribution D on [1,N] if ##EQU12## where ##EQU13## (resp.) is the probability that AL on input yε[1,N] outputs 1. The probability space is the set of all yε[1,N], distributed according to D (with uniform distribution, resp.) and of all 0-1 sequences of internal coin tosses of algorithm AL. Using this notion we can reformulate Theorem 2.3 as follows.

Corollary 2.4 Let d, N be integers such that gcd(d,φ(N))=1. Every probabilistic algorithm AL, that ε_(N) -rejects RSA-ciphertexts x^(d) (mod N) of even random messages x can be transformed (uniformly in N) into a probabilistic algorithm for decoding arbitrary RSA-ciphertexts. This deciphering algorithm terminates after at most ##EQU14## elementary steps (i.e. _(N) operations, RSA encryptions and calls for AL).

We next show that Corollary 2.4 remains valid if we replace RSA-ciphertexts of random even messages x, by RSA-ciphertexts of random messages xε[1,N/2].

Corollary 2.5 Let d, N be odd integers such that gcd(d,φ(N))=1. Every probabilistic algorithm AL, that ε_(N) -rejects RSA-ciphertexts x^(d) (mod N) of random messages xε[1,N/2] can be transformed (uniformly in N) into a probabilistic algorithm for decoding arbitrary RSA-ciphertexts. This deciphering algorithm terminates after at most ##EQU15## elementary steps.

Proof For odd N and all xε[1,N] we have

    xε[1,N/2]←2x(mod N) is even.

We see from this equivalence that the following distributions are identical for odd N:

.x^(d) (mod N) for random xε[1,N/2],

.2^(-d) y^(d) (mod N) for random even yε[1,N].

Moreover we can transform in polynomial time y^(d) (mod N) into 2^(-d) y^(d) (mod N). Thus an ε_(N) -rejection of RSA-encipherings x^(d) (mod N) of random messages xε[1,N/2] can be transformed (uniformly in N) into an ε_(N) -rejection of RSA-ciphertexts y^(d) (mod N) of random even yε[1,N]. Corollary 2.5 follows from Corollary 2.4 by this transformation.

Under the assumption that the RSA-scheme is safe Corollary 2.5 proves a slight modification of our hypothesis. The interval [1,2^(l) ] of Hypothesis 2.1 is replaced by the interval [1,N/2] in this modification. This poses the question whether the length of the interval is crucial for the hypothesis to be valid. We next show that Hypothesis 2.1, with the interval [1,2^(l) ] replaced by the interval ##EQU16## is valid if the RSA-scheme is safe.

Theorem 2.6 Let d, N be odd integers such that gcd(d,φ(N))=1. Every probabilistic algorithm AL, that ε_(N) -rejects RSA-ciphertexts x^(d) (mod N) of random messages xε[1, N2^(-k) ] can be transformed (uniformly in N) into a probabilistic algorithm for decoding arbitrary RSA-ciphertexts. This deciphering algorithm terminates after at most ##EQU17## elementary steps.

Proof Under the assumption that the RSA-scheme is safe, Alexi et alii (1985) have shown that the log n least significant bits of RSA-messages x are pseudo-random when given x^(d) (mod N), d and N. Their proof transforms every algorithm that ε_(N) -rejects RSA-encipherings x^(d) (mod N) of random messages x satisfying x=0(mod 2^(k)), (uniformly in N) into a probabilistic algorithm for deciphering arbitrary RSA-ciphertexts. This RSA-deciphering procedure terminates after at most ##EQU18## elementary steps (i.e. _(N) -operations, RSA-encipherings and calls for algorithm AL).

For odd N and all xε[1,N] we obviously have

    xε[1,N2.sup.-k ]←2.sup.k x(mod N)=0(mod 2.sup.k).

Therefore the following two distributions are identical for odd N:

x^(d) (mod N) for random xε[1,N2^(-k) ],

2^(-kd) y^(d) (mod N) for random yε[1,N 2^(-k) ] satisfying y=0(mod 2^(k)).

Moreover we can transform in polynomial time y^(d) (mod N) into 2^(-kd) y^(d) (mod N). Thus an ε_(N) -rejection of RSA-ciphertexts x^(d) (mod N) of random messages xε[1,N 2^(-k) ] can be transformed (uniformly in N) into an ε_(N) -rejection of RSA-ciphertexts y^(d) (mod N) of random messages y satisfying y=0(mod 2^(k)). Corollary 2.6 follows from this transformation and the above mentioned proof of Alexi et alii (1985).

Notice that the time bound for the RSA-deciphering algorithm of Corollary 2.6 is polynomially related to the time bound of algorithm AL provided that k≦log n. Hence if Hypothesis 2.1 fails, with the interval [1,2^(l) ] replaced by the interval [1, N2⁻ log n ], then RSA-ciphertexts can be deciphered in polynomial time. Also if Hypothesis 2.1 fails, with the interval [1,2^(l) ] replaced by the interval ##EQU19## then RSA-ciphertexts can be deciphered in time ##EQU20## However the fastest known algorithm for RSA-deciphering, via factoring N, requires about ##EQU21## steps, where 0.693≈log2. Thus if Hypothesis 2.1 fails for the interval ##EQU22## then we can speed up the presently known attacks to the RSA-scheme.

It remains the question whether the computational properties of the distribution x^(d) (mod N) change when x ranges over very small integers x. In fact Hypothesis 2.1 does not hold for the interval [1,N^(1/d) ] since we have x^(d) <N for all xε[1,N^(1/d) ] and therefore RSA-ciphertexts x^(d) (mod N) can easily be deciphered for xε[1,N^(1/d) ]. On the other hand the d-powers x^(d) are of order N² for almost all numbers xε[1,2^(l) ]. We conjecture that this is sufficient to make the task of deciphering x^(d) (mod N) hard. This is justified because inverting the squaring

    x→x.sup.2 (mod N)

is known to be as hard as factoring N, and the squares x² are of order N², too.

We are going to study the question whether Hypothesis 2.1 should be extended to polynomials P(x) that are more general than RSA-polynomials P(x)=x^(d) with gcd(d,φ(N))=1. There is an obvious extension of Hypothesis 2.1 to arbitrary exponents d≧2. It seems that the condition gcd(d,φ(N))=1 is not necessary for odd d. But we must modify the hypothesis for even d since the Jacobi-symbol gives efficient information on the quadratic residuosity. We formulate the extended hypothesis so that it can be applied in the proof of Theorem 3.1 to establish perfect RNG's. For reasons of efficiency we are particularly interested in even exponents d and in exponents that are powers of 2.

Extension to even d of Hypothesis 2.1: For random NεS_(n), all M=θ(2^(l)), random xε[1,M] and y:=x^(d) (mod N), z:= y/2^(n-l) the following holds.

(1) y and z^(d) (mod N) are pseudo-random quadratic residues,

(2) the number y(mod 2^(n-l)) is pseudo-random in [1,2^(n-l) ],

(3) z^(d) (mod N) and y(mod 2^(n-l)) are pseudo-independent.

The extended hypothesis can be justified by the work of Alexi et alii (1984) for the case that N is a Blum-integer, i.e. N is product of two primes p and q such that p=3(mod 4) and q=3(mod 4). Roughly speaking, it does not matter that y=x^(d) (mod N) ranges over quadratic residues. None of the disjoint parts z and y(mod 2^(n-l)) of y contains efficient information on the quadratic residuosity of x^(d) (mod N). The dependence of z and y(mod 2^(n-l)), by the quadratic residuosity of y, is hidden by the transformation z→z^(d) (mod N).

Next we consider arbitrary polynomials P(x) of degree d. We are going to show that some elementary methods for distinguishing random numbers yε[1,N] and P(x) mod N for random xε[1,N^(2/d) ] do not work. Theorem 2.7 is a first step in this direction. This problem clearly deserves further study.

In general we can invert the transformation

    x→P(x) mod N                                        (1)

only if the factorization N=pq is given. Then, using Berlekamps algorithm for polynomial factorization we invert (1) modulo p and modulo q and apply the Chinese remainder construction. This can be done in probabilistic time (nd)^(o)(1). Without knowing the factorization of M we do not know how to invert (1). We can however invert factors P(x) of x.sup.φ(N) provided that we know the cofactor x.sup.φ(N) /P(x) but then we can factor N.

Can we invert (1) for small integers x? If |P(x)|/N is small we can guess z=P(x) and factorize P(x)-z. Theorem 2.7 below shows that |P(x)|/N is large for almost all xε[1,N^(2/d) ] provided that P(x) has degree≦N^(1/2d). This degree bound is necessary since there exist polynomials of degree N^(2/d) that vanish on the intervall [1,N^(2/d) ].

Theorem 2.7 Let A,B,d be integers such that M≧(BN)^(1/d) 16Ad, and let P(x)ε [x] have degree d. Then we have prob[|P(x)|≦BN]≦1/A for random xε[1,M].

Proof Let x₁, . . . , x_(k) be the distinct real numbers in [0,N] satisfying P(x_(i))² =B² N² for i=1, . . . , k. We have k≦2d since P(x)² has degree 2d. We partition the real interval [0,M] into 4Ad intervals of length M/(4Ad). A fundamental theorem in approximation theory (see e.g. Stiefel (1969), p. 236) implies that ##EQU23## for each of these intervals I. Hence ##EQU24## This shows that every interval I, that contains an integer x satisfying |P(x)|≦BN, must also contain some point x_(i), 1≦i≦k≦2d. The intervals I that contain some point x_(i) can have at most ##EQU25## integer points. This accounts for at most a fraction of ##EQU26## of the points in [1, M].

The Sequential and the Parallel Polynomial Generator

In this section we build several RNG's on polynomials P(x) of degree d≧2 that have the following generator property. The generator property formulates Hypothesis 2.1 for arbitrary polynomials P(x).

Definition The polynomial P(x) has the generator property if for random NεS_(n), all M proportional to N^(2/d) and random xε[1,M] the number P(x) mod N is pseudo-random in [1,N].

The generator property means that P stretches random seeds xε[1,N^(2/d) ] into pseudo-random numbers P(x) mod N in the interval [1,N]. By Hypothesis 2.1 RSA-polynomials P(x)=x^(d) with gcd(d,φ(N))=1 and d≧3 have the generator property.

The sequential polynomial generator (SPG) generates a sequence of numbers x=x₁, x₂, . . . , x_(i), . . . , in [1,N^(2/d) ] that are represented by bit strings of length l:= 2n/d . The output at x_(i), Out(x_(i))ε{0,1}^(n-l), is the bit string consisting of the n-l least significant bits of the binary representation of P(x_(i)) mod N. The successor x_(i+1) of x_(i) is the number corresponding to the other bits of P(x_(i)) mod N,

    x.sub.i+1 := P(x.sub.i) mod N/2.sup.n-l  .

The sequential polynomial generator as illustrated in FIG. 6.

Let the k-output of the SPG ##EQU27## be the concatenated output of the first k steps.

Notice that the most significant bits of P(x_(i)) mod N are biased depending on the most significant bits of N. Even though the most significant bits of P(x_(i)) mod N are not pseudo-random we can form from these bits the successor x_(i+1) of x_(i). This is because the generator property and Hypothesis 2.1 imply that P(x_(i)) mod N is pseudo-random for random numbers x_(i) ε[1,M] for all M proportional to 2^(l). We could fix M to 2^(l) if the SPG would not use at all the l most significant bits of P(x_(i)) mod N, and would form Out(x_(i)) and x_(i+1) from the n-l least significant bits.

Theorem 3.1 Suppose that P has the generator property. Then for random NεS_(n), random xε[1,N^(2/d) ] and polynomially bounded k (i.e. k=k(n)=n^(O)(1)) the k-output SPG_(k),p (x,N) of the sequential polynomial generator is pseudo-random.

Proof For random NεS_(n) and random x₁ ε[1,N^(2/d) ] the number P(x₁) mod Nε[1,N] is pseudo-random. It follows that the bit string Out(x₁)ε{0,1}^(n-l) is pseudo-random and that the number x₂ ε[1,2^(l) ] is pseudo-random. We also see that the pair (Out(x₁), x₂) is pseudo-random. It follows from the generator property and since x₂ is pseudo-random that

    (Out(x.sub.1)Out(x.sub.2),x.sub.3)=(SPG.sub.2,P (x.sub.1,N),x.sub.3)

is pseudo-random, too. To prove this claim we replace in a statistical test T=(T_(n))_(n)ε for z:=(Out(x₁) Out(x₂), x₃) either (Out(x₂), x₃) or Out (x₁) by independent random objects generated through internal coin tosses. This transforms T into statistical test for P(x₂) mod N (P(x₁)mod N, resp.). If z is ε_(n) -rejected then either P(x₂) mod N or P(x₁) mod N is (ε_(n) /2)-rejected. In either case this yields a statistical test that (ε_(n) /2)-rejects P(x₁) mod N.

By induction on k the same argument proves that

    (SPG.sub.k,P (x.sub.1,N),x.sub.k+1)

is pseudo-random for every fixed k. The pseudo-randomness also holds if k=k(n) depends on n if k is polynomially bounded in n, i.e. k=n^(o)(1). Using the above argument we can transform a test that ε_(n) -rejects (SPG_(k),P (x₁,N), x_(k+1)) into a test that (ε_(n) /k)-rejects P(x₁) mod N.

It is important that the above proof also applies to polynomials P(x)=x^(d) with even d. Instead of using the generator property of P we can use the extension to even d of Hypothesis 2.1. Speaking informally, it does not hurt that x^(d) (mod N) ranges over quadratic residues since the output merely contains the least significant bits of x^(d) (mod N) and these bits give no efficient information on the quadratic residuosity of x^(d) (mod N). Thus we can use for random bit generation the polynomial P(x)=x¹⁶ which yields particular efficient generators.

PRACTICAL POLYNOMIAL GENERATORS

For practical applications let N be a fixed product of two random primes p and q which each is 256 bits long. N^(2/d) must be so large that it is infeasible to enumerate a non-negligible part of [1,N^(2/d) ]. We recommend that d≦16 so that N^(2/d) ≧2⁶⁴.

EXAMPLE 1

Let N be n=512 bits long and let gcd(15,φ(N))=1. We choose d=15, P(x)=x¹⁵. Let Out(x_(i)) consist of the 440 least significant bits of P(x_(i)) mod N and let x_(i+1) be the number corresponding to the 68 most significant bits of P(x_(i)) mod N. We compute x¹⁵ (mod N) by computing x², x⁴, x⁸, x⁷ =x⁴ . x² . x and x¹⁵ =x⁸ . x⁷ (mod N). Only the last multiplication requires modular reduction. The other multiplications are with small numbers. The costs of one iteration step correspond to one full modular multiplication. Thus this SPG iteratively outputs 440 pseudo-random bits at the cost of one full modular multiplication with a modulus that is 512 bits long.

EXAMPLE 2

Another suitable polynomial is P(x)=x¹⁶ even though this polynomial does not have the generator property. The computation of x¹⁶ (mod N) is particularly easy; we compute x², x⁴, x⁸ and x¹⁶ =x⁸ . x⁸ (mod N). The SPG with P(x)=x¹⁶ iteratively outputs 448 bits at the cost of one full modular multiplication with a modulus N that is 512 bits long.

Next we are going to extend the SPG to a generator which we can speed by parallelization. The parallel polynomial generator (PPG) generates from random seed xε[1,N^(2/d) ] a tree with root x and outdegree at most d/2. The nodes of this iteration tree are pseudo-random numbers in [1,N^(2/d) ] that are represented by bit strings of length l.

The successors y(1), . . . , y(s) of a node y with degree s and the output string Out(y) at y are defined as follows. Let b₁, . . . , b_(n) be the bits of the binary representation of P(y) mod N, with b₁ being the most significant bit, i.e. ##EQU28## We partition the sl most significant bits into s block with l bits in each block. The corresponding numbers ##EQU29## are the successors of node y in the iteration tree. The output Out(y) at node y consists of the remaining low order bits of P(y) mod N,

    Out(y)=b.sub.sl+1 . . . b.sub.n.

For convenience we denote the nodes on level k of the iteration tree as x(j₁, . . . , j_(k)); x(j₁, . . . , j_(k-1)) is the direct predecessor of x(j₁, . . . , j_(k)) and j_(k) ranges from 1 to s_(k-1) ="outdegree of x(j₁, . . . , j_(k-1))". For simplicity we let the outdegree of node x(j₁, . . . , j_(k)) be a function depending on k only; we assume that s_(k) ≧1.

The parallel polynomial generator can be figured by the infinite tree of FIG. 7.

We define the k-output PPG_(k),P (x,N) of the PPG with seed x as the concatenation of all bit strings Out(x(j₁, . . . , j_(i))) on levels i with 0≦i≦k, with respect to any efficient enumeration order, as e.g. preorder traversal, postorder traversal, inorder traversal or enumeration by levels.

In the particular case that all outdegrees are one, i.e. s₀ =s₁ =. . . =s_(k) =1, the parallel and the sequential polynomial generator coincide. The argument of Goldreich, Goldwasser and Micali (1986) extends Theorem 3.1 from the SPG to arbitrary PPG's, provided that we process at most polynomially many nodes in the iteration tree. This yields the following theorem.

Theorem 3.2 Suppose that P has the generator property. Then for random NεS_(n), random xε[1,2^(l) ] the k-output PPG_(k),P (x,N) of the parallel polynomial generator is pseudo-random provided that the length of PPG_(k),P (x,N) is polynomially bounded.

Idea of proof

There is a straightforward way to extend the proof of Theorem 3.1. Suppose that the k-output PPG_(k),P (x,N) collects the outputs of k nodes. Then every statistical test that ε_(n) -rejects PPG_(k),P (x,N) for random xε[1,N^(2/d) ] and random NεS_(n) can be transformed into a statistical test that (ε_(n) /k)-rejects P(x) mod N.

For the output of the PPG we can use any efficient enumeration for the nodes of the iteration tree. To support parallel evaluation we can adjust the shape of the iteration tree and the enumeration order to the number of available parallel processors. In Example 3 we form, for 8 parallel processors, an iteration tree consisting of 8 rays attached to the root; the nodes are enumerated by levels and within levels from left to right. For m parallel processors we can use any iteration tree consisting of m isomorphic subtrees attached to the root; we can enumerate, in any order, the m-tuples of corresponding nodes in these subtrees. The enumeration within the subtrees can be chosen to support fast retrieval; for this we can enumerate the nodes e.g. in preorder traversal or in inorder traversal. It is an obvious but important observation that m processors can speed the pseudo-random bit generation of the PPG by a factor m. Once we are given m nodes on the same level of the iteration tree we can process the subtrees below these nodes independently by m parallel processors. These processors do not need to communicate.

Corollary 3.3 Using m processors in parallel we can speed the pseudo-random bit generation of the parallel polynomial generator by a factor m.

PRACTICAL PARALLEL POLYNOMIAL GENERATORS

Let N be product of two random primes so that N is 512 bits long. Let P(x)=x¹⁶.

EXAMPLE 3

We construct from random xε[1,2⁶⁴ ] a tree with 8 nodes per level. (FIG. 8)

1. Stretch a random seed xε[1,2⁶⁴ ] into x¹⁶ (mod N).

2. Partition the binary representation of x¹⁶ (mod N) into 8 bit strings x(1), . . . , x(8) of length 64. Put k=1 and let PPG₁,P (x,N) the empty string.

3. For j=1, . . . , 8 let x(j 1^(k))εI₆₄ consist of the 64 most significant bits of the binary representation of x(j 1^(k-1))¹⁶ mod N, and let Out(x(j 1^(k)))εI₄₄₈ consist of the remaining 448 least significant bits.

4. ##EQU30##

Using 8 parallel processors this PPG iteratively generates 8 . 448=3584 pseudo-random bits in the time for one full modular multiplication with a modulus N that is 512 bits long. With current processors for smart cards such a full modular multiplication can be done in less than 0.2 sec. Thus 8 parallel processors can generate about 18000 pseudo-random bits per sec.

EXAMPLE 4

We construct from random xε[1,2⁶⁴ ] a complete tree of outdegree 4.

1. Choose a random seed xε[1,2⁶⁴ ] for root of the tree.

2. For every node yε[1,2⁶⁴ ] of the tree compute the successors y(1), . . . , y(4) and the output Out(y) of y¹⁶ (mod N) by partitioning the binary representation B of y¹⁶ (mod N) as

    B=B.sub.1 B.sub.2 B.sub.3 B.sub.4 Out(y)εI.sub.64.sup.4 ×I.sub.256

and compute for i=1, . . . , 4

    y(i):=1+"the number with binary representation B.sub.i ".

The main interest in such a PPG comes from fast retrieval methods.

Fast retrieval for the PPG: If the PPG has a complete iteration tree one can efficiently retrieve substrings of the output. Consider example 4 with a complete iteration tree of outdegree 4. Level k of the tree has 4^(k) nodes and the first k levels have about 4^(k) . 5/4 nodes in total. Suppose the nodes of the tree are enumerated in preorder traversal. Each node yields 256 output bits. To retrieve node y we follow the path from the root to y. This requires processing and storage of at most k nodes and can be done at the costs of about k full modular multiplications. Once we have retrieved node y and stored the path from the root to node y, the bit string that follows Out(y) in the output can be generated by standard methods at the speed of 256 bits per modular multiplication. For most practical applications the depth k will be at most 30 which permits to generate a pseudo-random string that is 3.7 . 10²⁰ bits long. We see that retrieval of substrings is very efficient, it merely requires a preprocessing stage of a few seconds to retrieve the initial segment of the substring.

Theorem 3.4 Every node y of depth k in the iteration tree of the PPG can be accessed and processed at the costs of O(k) modular multiplications.

                                      TABLE                                        __________________________________________________________________________     retrieval performance of the PPG, example 4                                    k        5    10   15   20   25   30                                           __________________________________________________________________________     # nodes in                                                                              1280 1.3· 10.sup.6                                                              1.3· 10.sup.9                                                              1.3· 10.sup.12                                                             1.4· 10.sup.15                                                             1.4· 10.sup.18                      The first k levels                                                             # output bits                                                                           3.3· 10.sup.5                                                              3.3· 10.sup.8                                                              3.4· 10.sup.11                                                             10.sup.14                                                                           3.6· 10.sup.17                                                             3.7· 10.sup.20                      __________________________________________________________________________

Parallelization and fast retrieval for arbitrary perfect RNG's

It is an important observation that the above methods of parallelization and of efficient retrieval apply to every perfect RNG (G_(n))_(n)ε . The parallel version of the generator associates an iteration tree to a random seed. For example let G_(n) :I_(n) →I_(3n) stretch a random strings in I_(n) into pseudo-random strings in I_(3n). We construct from random seed x εI_(n) a binary iteration tree with nodes in I_(n). Let x be the root of the tree. Construct the two successors y(1), y(2) and the output Out(y) of node y by partitioning G_(n) (y)εI_(3n) into three substrings of length n,

    G.sub.n (y)=y(1)y(2) Out(y).

Let PG_(k),G (x) be the concatenated output of all nodes with depth at most k (compare with the definition of PPG_(k),P (x,N)).

Theorem 3.5 Let (G_(n))_(n)ε be any perfect RNG. Then for random seed xεI_(n) the concatenated output PG_(k),G (x) of all nodes with depth≦k is pseudo-random provided that its length is polynomially bounded in n.

We illuminate our method of parallelization in applying it to some less efficient versions of the RSA/Rabin generator. Let N be a product of two random primes such that N is 512 bits long and gcd(3,φ(N))=1.

EXAMPLE 5

From random seed xε[1,N] we generate the sequence of numbers x₁, x₂, . . . , x_(i), . . . ε[1,N] as

    x.sub.1 =x, x.sub.i+1 =x.sub.i.sup.3 (mod N).

Under the assumption that the RSA-enciphering x→x³ (mod N) is safe for the particular N, Alexi et alii (1984) have shown that about the 16 least significant bits of x_(i) are pseudo-independent from x_(i+1). This suggest the following output of x_(i)

    Out(x.sub.i)="the 16-least significant bits of x.sub.i ".

Thus for random x₁ ε[1,N] and under the assumption that RSA-enciphering is safe we obtain pseudo-random bit strings ##EQU31## Out(x_(i)) of length 1600. We apply a binary tree construction to the function

    G:I.sub.512 →I.sub.1600

that stretches the binary representation of x₁ ε[1,N] into ##EQU32## Out(x_(i)). The binary tree has nodes in I₅₁₂. The successors y(1), y(2) and the output of node y are obtained by partitioning G(y) into two successor strings of length 512 and an output string Out_(G) (y) εI₅₇₆. Processing a node of the binary iteration tree costs 200 modular multiplication.

EXAMPLE 6

We can accelerate this generator under the reasonable assumption that the 448 least significant bits of random xε[1,N] and the number x³ (mod N) are pseudo-independent. We set

    Out(x.sub.i):="the 448 least significant bits of x.sub.i ",

and it follows that ##EQU33## Out(x_(i))εI₁₃₄₄ is pseudo-random for random x₁ ε[1,N]. We apply the binary tree construction to the function

    G:I.sub.512 →I.sub.1344

that stretches the binary representation of x₁ ε[1,N] into ##EQU34## Out(x_(i)). The successors y(1), y(2)εI₅₁₂ and the output Out_(G) (y)εI₃₂₀ of node y are obtained by partitioning G(y)εI₁₃₄₄ into two strings in I₅₁₂ and Out_(G) (y)εI₃₂₀. Processing a node of the binary tree costs 6 modular multiplications.

EXAMPLE 7

We can further speed up this generator under the assumption that the 448 least significant bits of random xε[1,N] are pseudo-independent of x² (mod N). (It follows from Alexi et alii (1984) that the 16 least significant bits of random xε[1,N] are pseudo-independent of x² (mod N) if factoring the particular N is hard. Under this assumption we can replace the iteration ##EQU35## by ##EQU36## As in Example 5 we associate with a random xε[1,N] a binary iteration tree with nodes in I₅₁₂. Processing a node of this tree costs about 4 modular multiplications and yields 320 pseudo-random bits for output.

It is interesting to compare the efficiency of these parallel RNG's with the parallel RNG's based on Hypothesis 2.1. For the latter RNG's in examples 1-4 the cost per node of the iteration tree is about 1 mulitplication modulo N. This shows that the new perfect RNG's are more suitable for our method of parallelization and fast retrieval.

References

Alexi, W., Chor, B., Goldreich, O., and Schnorr, C. P.: RSA and Rabin Functions: certain parts are as hard as the whole. Proceeding of the 25th Symposium on Foundations of Computer Science, 1984, pp. 449-457; also; Siam Journal on Comput., (1988).

Blum, L., Blum, M. and Shub, M.: A simple unpredictable pseudo-random number generator. Siam J. on computing (1986), pp. 364-383.

Blum, M. and Micali, S.: How to generate cryptographically strong sequences of pseudo-random bits. Proceedings of the 25th IEEE Symposium on Foundations of Computer Science, IEEE, New York (1982); also Siam J. Comput. 13 (1984), pp. 850-864.

Goldreich, O., Goldwasser, S., Micali, S.: How to Construct Random Functions. Proceedings of the 25th IEEE Symposium on Foundations of Computer Science, IEEE, New York, (1984); also Journal ACM 33,4 (1986), pp. 792-807.

Knuth, D. E.: The Art of Computer Programming. Vol. 2, second edition. Addison Wesley (1981).

Luby, M. and Rackoff, Ch.: Pseudo-random permutation generators and cryptographic composition. Proceedings of the 18th ACM Symposium on the Theory of Computing, ACM, New York (1985) pp. 356-363.

Stern, J.: Secret linear congruential generators are not cryptographically secure. Proceedings of the 28th IEEE-Symposium on Foundations of Computer Science (1987) pp. 421-426.

Stiefel, E.: Einfuhrung in die numerische Mathematik. Teubner, Stuttgart (1969).

Yao, A. C.: Theory and applications of trapdoor functions. Proceedings of the 25th IEEE Symposium on Foundations of Computer Science, IEEE, New York (1982), pp. 80-91.

While this invention has been particularly shown and described with references to preferred embodiments thereof, it will be understood by those skilled in the art that various changes in form and details may be made therein without departing from the spirit and scope of the invention as defined by the appended claims. 

We claim:
 1. A random sequence generator for generating a random sequence from a seed random sequence of substantially shorter length, the generator performing a tree operation by extending, at each node of a tree structure, a node input random sequence into a longer node output random sequence, a plurality of node output random sequences of the tree structure together comprising a final random output sequence.
 2. A random sequence generator as claimed in claim 1 wherein each node input sequence is extended by the operation

    y=a.sub.e x.sup.e +a.sub.e-1 x.sup.e-1 + . . . +a.sub.1 x+a.sub.0 (mod N)

where e, a_(e), a_(e-1), . . . ,a₀ and N are integers, the node input sequence represents x and the node output sequence represents y.
 3. A random sequence generator as claimed in claim 2 wherein there is at least one a_(d) of a_(e),a_(e-1), . . . ,a₃ not equal to zero and the greatest common divisor of d and φ(N) is equal to one where φ(N) is Euler's Totient function.
 4. A random sequence generator as claimed in claim 2 where N is the product of two large random primes p and q.
 5. A random sequence generator as claimed in claim 4 wherein at least one a_(d) of a_(e), a_(e-1), . . . ,a₃ is nonzero, and d is an integer that is relatively prime to (p-1)(q-1).
 6. A random sequence generator as claimed in claim 5 wherein all coefficients of the polynomial of y are equal to zero except the coefficient a₃.
 7. A random sequence generator as claimed in claim 6 where a₃ is equal to one.
 8. A random sequence generator as claimed in claim 1 wherein each node input sequence is extended by the operation

    y=ax.sup.d (mod N)

where N is the product of two large random primes p and q, d is an integer that is relatively prime to (p-1)(q-1), the node input sequence represents x and the node output sequence represents y.
 9. A random sequence generator as claimed in claim 8 wherein d is equal to
 3. 10. A random sequence generator as claimed in claim 1 wherein each node input sequence is extended by a single modular operation.
 11. A random sequence generator as claimed in claim 1 wherein less than all of the bits of node output sequences are reapplied as node input sequences of the tree structure.
 12. A random sequence generator for generating a random sequence from a seed random sequence of substantially shorter length, the generator performing a tree operation by extending, at each node of a tree structure, a node input random sequence into a longer node output random sequence, a final random output sequence being generated as successive leaves of the tree structure.
 13. A random sequence generator as claimed in claim 12 wherein each node input sequence is extended by the operation

    y=ax.sup.d (mod N)

where N is the product of two large random primes p and q, d is an integer that is relatively prime to (p-1)(q-1), the node input sequence represents x and the node output sequence represents y.
 14. A random sequence generator as claimed in claim 13 wherein d is equal to
 3. 15. A random sequence generator as claimed in claim 12 wherein each node input sequence is extended by a single modular operation.
 16. A random sequence generator as claimed in claim 12 wherein each node input sequence is extended by the operation

    y=a.sub.e x.sup.e +a.sub.e-1 x.sup.e-1 + . . . +a.sub.1 x+a.sub.0 (mod N)

where e, a_(e), a_(e-1), . . . ,a₀ and N are integers, the node input sequence represents x and the node output sequence represents y, and where there is at least one a_(d) of a_(e), a_(e-1), . . . ,a₃ not equal to zero and the greatest common divisor of d and φ(N) is equal to one where φ(N) is Euler's Totient function.
 17. A random sequence generator for generating a random sequence from a seed random sequence of substantially shorter length, the generator comprising a plurality of processors, each processor extending a node input random sequence into a longer node output random sequence, each of the plurality of processors performing a portion of a tree structure by extending a node input sequence and then separately extending different portions of a node output sequence in successive operations at successive nodes of the tree structure.
 18. A random sequence generator as claimed in claim 17 wherein each node input sequence is extended by the operation

    y=ax.sup.d (mod N)

where N is the product of two large random primes p and q, d is an integer that is relatively prime to (p-1)(q-1), the node input sequence represents x and the node output sequence represents y.
 19. A random sequence generator as claimed in claim 18 wherein d is equal to
 3. 20. A random sequence generator as claimed in claim 17 wherein each node input sequence is extended by a single modular operation.
 21. A random sequence generator as claimed in claim 17 wherein each node input sequence is extended by the operation

    y=a.sub.e x.sup.e +a.sub.e-1 x.sup.e-1 + . . . +a.sub.1 x+a.sub.0 (mod N)

where e, a_(e), a_(e-1), . . . ,a₀ and N are integers, the node input sequence represents x and the node output sequence represents y, and where there is at least one a_(d) of a_(e), a_(e-1), . . . ,a₃ not equal to zero and the greatest common divisor of d and φ(N) is equal to one where (N) is Euler's Totient function.
 22. A method of generating a random sequence from a seed random sequence of substantially shorter length, comprising performing a tree operation by extending, at each node of the tree structure, a node input random sequence into a longer node output random sequence, a final random output sequence being generated from successive leaves of the tree structure.
 23. A method as claimed in claim 22 wherein each node input sequence is extended by the operation

    y=ax.sup.d (mod N)

where N is the product of two large random primes p and q, d is an integer that is relatively prime to (p-1)(q-1), the node input sequence represents x and the node output sequence represents y.
 24. A method as claimed in claim 23 wherein d is equal to
 3. 25. A method as claimed in claim 22 wherein each node input sequence is extended by a single modular operation.
 26. A random sequence generator as claimed in claim 22 wherein each node input sequence is extended by the operation

    y=a.sub.e x.sup.e +a.sub.e-1 x.sup.e-1 + . . . +a.sub.1 x+a.sub.0 (mod N)

where e, a_(e), a_(e-1), . . . ,a₀ and N are integers, the node input sequence represents x and the node output sequence represents y, and where there is at least one a_(d) of a_(e), a_(e-1), . . . ,a₃ not equal to zero and the greatest common divisor of d and φ(N) is equal to one where φ(N) is Euler's Totient function.
 27. A method of generating a random sequence from a seed random sequence of substantially shorter length comprising performing a tree operation by extending, at each node of a tree structure, a node input random sequence into a longer node output random sequence, a plurality of node output random sequences of the tree structure together comprising a final random output sequence.
 28. A method as claimed in claim 27 wherein each node input sequence is extended by the operation

    y=ax.sup.d (mod N)

where N is the product of two large random primes p and q, d is an integer that is relatively prime to (p-1)(q-1), the node input sequence represents x and the node output sequence represents y.
 29. A method as claimed in claim 28 wherein d is equal to
 3. 30. A method as claimed in claim 27 wherein each node input sequence is extended by a single modular operation.
 31. A random sequence generator as claimed in claim 27 wherein each node input sequence is extended by the operation

    y=a.sub.e x.sup.e +a.sub.e-1 x.sup.e-1 + . . . +a.sub.1 x+a.sub.0 (mod N)

where e, a_(e), a_(e-1), . . . ,a₀ and N are integers, the node input sequence represents x and the node output sequence represents y, and where there is at least one a_(d) of a_(e), a_(e-1), . . . ,a₃ not equal to zero and the greatest common divisor of d and φ(N) is equal to one where φ(N) is Euler's Totient function.
 32. A method of generating a random sequence from a seed random sequence of substantially shorter length comprising in each of a plurality of processors, extending a node input random sequence into a longer node output random sequence, each of the plurality of processors performing a portion of a tree structure by extending a node input sequence and then separately extending different portions of a node output sequence in successive operations at successive nodes of the tree structure.
 33. A method as claimed in claim 32 wherein each node input sequence is extended by the operation

    y=ax.sup.d (mod N)

where N is the product of two large random primes p and q, d is an integer that is relatively prime to (p-1)(q-1), the node input sequence represents x and the node output sequence represents y.
 34. A method as claimed in claim 33 wherein d is equal to
 3. 35. A method as claimed in claim 32 wherein each node input sequence is extended by a single modular operation.
 36. A random sequence generator as claimed in claim 32 wherein each node input sequence is extended by the operation

    y=a.sub.e x.sup.e +a.sub.e-1 x.sup.e-1 + . . . +a.sub.1 x+a.sub.0 (mod N)

where e, a_(e), a_(e-1), . . . ,a₀ and N are integers, the node input sequence represents x and the node output sequence represents y, and where there is at least one a_(d) of a_(e), a_(e-1), . . . ,a₃ not equal to zero and the greatest common divisor of d and φ(N) is equal to one where φ(N) is Euler's Totient function.
 37. An encryption system comprising an encryption unit for performing a transform between encrypted and nonencrypted messages, based on an extended random sequence, and a random sequence generator for generating the random sequence from a seed random sequence and an index input, the random sequence generator performing a tree operation by extending, at each node of a tree structure, a node input random sequence into a longer node output random sequence.
 38. An encryption system as claimed in claim 37 wherein each node input sequence is extended by the operation

    y=ax.sup.d (mod N)

where N is the product of two large random primes p and q, d is an integer that is relatively prime to (p-1)(q-1), the node input sequence represents x and the node output sequence represents y.
 39. An encryption system as claimed in claim 38 wherein d is equal to
 3. 40. An encryption system as claimed in claim 37 wherein each node input sequence is extended by a single modular operation.
 41. An encryption system as claimed in claim 37 wherein the random sequence applied to the encryption unit comprises a plurality of node output random sequences of the tree structure.
 42. An encryption system as claimed in claim 41 wherein the random sequence applied to the encryption unit is generated as successive leaves of the tree structure.
 43. An encryption system as claimed in claim 37 wherein the random sequence generator comprises a plurality of processors, each of the plurality of processors performing a portion of the tree structure.
 44. A random sequence generator as claimed in claim 37 wherein each node input sequence is extended by the operation

    y=a.sub.e x.sup.e +a.sub.e-1 x.sup.e-1 + . . . +a.sub.1 x+a.sub.0 (mod N)

where e, a_(e), a_(e-1), . . . ,a₀ and N are integers, the node input sequence represents x and the node output sequence represents y, and where there is at least one a_(d) of a_(e), a_(e-1), . . . ,a₃ not equal to zero and the greatest common divisor of d and φ(N) is equal to one where φ(N) is Euler's Totient function.
 45. A method of message encryption comprising generating a random sequence from a seed random sequence and an index input, the random sequence being generated in a tree operation by extending, at each node of a tree structure, a node input random sequence into a longer node output random sequence and, based on the extended random sequence, performing a transform between encrypted and nonencrypted messages.
 46. A method as claimed in claim 45 wherein each node input sequence is extended by a single modular operation.
 47. A method as claimed in claim 45 wherein the random sequence applied to the encryption unit comprises a plurality of node output random sequences of the tree structure.
 48. A method as claimed in claim 47 wherein the random sequence applied to the encryption unit is generated as successive leaves of the tree structure.
 49. A method as claimed in claim 45 wherein the random sequence generator comprises a plurality of processors, each of the plurality of processors performing a portion of the tree structure.
 50. A random sequence generator as claimed in claim 45 wherein each node input sequence is extended by the operation

    y=a.sub.e x.sup.e +a.sub.e-1 x.sup.e-1 + . . . +a.sub.1 x+a.sub.0 (mod N)

where e, a_(e), a_(e-1), . . . ,a₀ and N are integers, the node input sequence represents x and the node output sequence represents y, and where there is at least one a_(d) of a_(e), a_(e-1), . . . ,a₃ not equal to zero and the greatest common divisor of d and φ(N) is equal to one where φ(N) is Euler's Totient function.
 51. A method of generating a random sequence from a random seed comprising, in each of iterative steps, applying a function to an input string of random bits to obtain an output string of bits, significantly less than all of an output string of bits being used in an input string of bits in each successive step, and utilizing other bits of the output string toward the random sequence.
 52. A method as claimed in claim 51 wherein each input string is about 2/3 or less of the bits of the output string from the previous step.
 53. A method as claimed in claim 51 wherein the other bits utilized toward the random sequence are a part of the generated random sequence.
 54. A method as claimed in claim 51 wherein the iterative steps are performed in a tree operation and the function is also applied to the other bits of the output string utilized toward the random sequence.
 55. A method as claimed in claim 51 wherein each output string of bits is obtained by the function

    y=a.sub.e x.sup.e +a.sub.e-1 x.sup.e-1 + . . . +a.sub.1 x+a.sub.0 (mod N)

where e, a_(e), a_(e-1), . . . ,a₀ and N are integers, the input string represents x and the output string represents y and where the number of bits in x is significantly less than the number of bits in N.
 56. A random sequence generator as claimed in claim 51 wherein each input string of bits is extended by the function

    y=a.sub.e x.sup.e +a.sub.e-1 x.sup.e-1 + . . . +a.sub.1 x+a.sub.0 (mod N)

where e, a_(e), a_(e-1), . . . ,a₀ and N are integers, the input string represents x and the output string represents y, and where there is at least one a_(d) of a_(e), a_(e-1), . . . ,a₃ not equal to zero and the greatest common divisor of d and φ(N) is equal to one where φ(N) is Euler's Totient function.
 57. A method of generating a random sequence from a random seed comprising, in each of iterative steps, applying a function to an input string of random bits to obtain an output string of bits, significantly less than all of an output string of bits being used as an input string of bits in each successive step, at least some of the bits of each output string being a part of the generated random sequence.
 58. A method as claimed in claim 57 wherein each input string is about 2/3 or less of the bits of the output string from the previous step.
 59. A method as claimed in claim 57 wherein each output string of bits is obtained by the function

    y=a.sub.e x.sup.e +a.sub.e-1 x.sup.e-1 + . . . +a.sub.1 x+a.sub.0 (mod N)

where e, a_(e), a_(e-1), . . . ,a₀ and N are integers, the input string represents x and the output string represents y and where the number of bits in x is significantly less than the number of bits in N.
 60. A random sequence generator as claimed in claim 57 wherein each input string of bits is extended by the function

    y=a.sub.e x.sup.e +a.sub.e-1 x.sup.e-1 + . . . +a.sub.1 x+a.sub.0 (mod N)

where e, a_(e), a_(e-1), . . . ,a₀ and N are integers, the input string represents x and the output string represents y, and where there is at least one a_(d) of a_(e), a_(e-1), . . . ,a₃ not equal to zero and the greatest common divisor of d and φ(N) is equal to one where φ(N) is Euler's Totient function. 